package com.tarena.lbs.activity.service.impl;

import com.tarena.lbs.activity.api.pojo.ActivityDto;
import com.tarena.lbs.activity.dao.repository.ActivityRepository;
import com.tarena.lbs.activity.enums.ActivityStatusEnum;
import com.tarena.lbs.activity.pojo.param.ActivityAddParam;
import com.tarena.lbs.activity.pojo.query.ActivityQuery;
import com.tarena.lbs.activity.pojo.vo.ActivityVO;
import com.tarena.lbs.activity.service.ActivityService;
import com.tarena.lbs.base.protocol.exception.BusinessException;
import com.tarena.lbs.base.protocol.pager.PageResult;
import com.tarena.lbs.user.api.UserApi;
import lombok.extern.slf4j.Slf4j;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

@Slf4j
@Service
public class ActivityServiceImpl implements ActivityService {
    @Autowired
    private ActivityRepository activityRepository;
    @DubboReference
    private UserApi userApi;

    /**
     * 根据ID获取活动详情
     *
     * @param id 活动ID
     * @return 活动详情信息，如果ID为空则返回null
     */
    @Override
    public ActivityVO activityDetail(Integer id) {
        log.debug("[服务层]处理显示活动详情,入参{}", id);
        //参数校验
        if (id == null) {
            return null;
        }
        return activityRepository.selectDetail(id);
    }

    /**
     * 分页查询活动列表
     *
     * @return 活动分页结果
     */
    @Override
    public PageResult<ActivityVO> pageList(ActivityQuery query) {
        log.debug("[服务层]处理显示活动列表,入参{}", query);
        return activityRepository.pageList(query);
    }

    /**
     * 保存活动信息
     *
     * @param param 活动新增参数
     * @return 插入记录数
     * @throws BusinessException 业务异常，当日期格式转换失败时抛出
     */
    @Override
    public int activitySave(ActivityAddParam param) throws BusinessException {
        log.debug("[服务层]处理保存活动,入参{}", param);
        //封装为ActivityVO
        ActivityVO activityVO = new ActivityVO();
        //转换日期
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            if (param.getStartDate() != null) {
                activityVO.setStartDate(sdf.parse(param.getStartDate()));
            }
            if (param.getEndDate() != null) {
                activityVO.setEndDate(sdf.parse(param.getEndDate()));
            }
        } catch (ParseException e) {
            log.error("日期转换失败", e);
            throw new BusinessException();
        }
        //复制属性
        BeanUtils.copyProperties(param, activityVO);
        //初始化属性
        activityVO.setStatus(ActivityStatusEnum.DISABLE.getCode());//新增时默认未开始
        activityVO.setEnableStatus(ActivityStatusEnum.ENABLE.getCode());//新增时默认启用
        activityVO.setActivityType(1);
        activityVO.setChannelType(1);
        activityVO.setRewardType(1);
        Date now = new Date();
        if (activityVO.getCreateAt() == null) {
            activityVO.setCreateAt(now);
        }
        activityVO.setUpdateAt(now);
        boolean isSave = false;
        if (activityVO.getId() != null) isSave = true;
        return isSave ? activityRepository.update(activityVO) : activityRepository.insert(activityVO);
    }


    /**
     * 更新活动状态
     *
     * @param id     活动ID
     * @param status 新的状态值
     * @return 更新记录数，若活动不存在则返回0
     */
    @Override
    public int updateActivityStatus(Integer id, Integer status) {
        log.debug("[服务层]处理更新活动状态,入参{}", id);
        //检验是否存在该数据
        Boolean exist = activityRepository.selectDetail(id) != null;
        if (!exist) {
            return 0;
        }
        return activityRepository.updateActivityStatus(id, status);
    }


    /**
     * 判断用户是否满足活动的目标人群范围
     *
     * @param userId     用户ID
     * @param activityId 活动ID
     * @return Boolean 用户是否满足活动目标人群范围，满足返回true，不满足或异常返回false
     */
    @Override
    public Boolean activityVisible(Integer userId, Integer activityId) {
        log.debug("[服务层]处理用户是否满足活动目标人群范围,入参[userId],[activityId]");

        // 获取活动详情
        ActivityVO activityVO = activityRepository.selectDetail(activityId);
        if (activityVO == null) {
            log.warn("活动不存在, activityId: {}", activityId);
            return false;
        }

        // 获取当前活动的目标人群ID和商家ID
        String targetCustomer = activityVO.getTargetCustomer();
        Integer businessId = activityVO.getBusinessId();

        // 通过RPC调用获取用户所属人群ID列表
        List<Integer> userGroupIds;
        try {
            userGroupIds = userApi.getUserGroupIds(userId, businessId);
        } catch (Exception e) {
            log.error("RPC调用获取用户人群ID失败, userId: {}, businessId: {}", userId, businessId, e);
            return false;
        }

        // 判断用户是否属于目标人群
        if (userGroupIds == null || userGroupIds.isEmpty()) {
            return false;
        }

        // 将目标人群ID转换为Set提高查找效率，并避免字符串contains的误匹配问题
        Set<String> targetCustomerSet = new HashSet<>();
        if (targetCustomer != null && !targetCustomer.isEmpty()) {
            String[] targetCustomers = targetCustomer.split(",");
            for (String customer : targetCustomers) {
                targetCustomerSet.add(customer.trim());
            }
        }

        // 遍历用户人群ID，判断是否包含在活动目标人群中
        for (Integer userGroupId : userGroupIds) {
            if (userGroupId != null && targetCustomerSet.contains(userGroupId.toString())) {
                return true;
            }
        }
        return false;
    }

    @Override
    public ActivityDto getActivityById(Integer activityId) {
        log.debug("[服务层]处理获取活动详情,入参{}", activityId);
        return activityRepository.getActivityById(activityId);
    }

}
